ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಜೆನೆರಿಕ್ಸ್: ಸುಧಾರಿತ ಬಳಕೆಯ ಮಾದರಿಗಳು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಜೆನೆರಿಕ್ಸ್ ಒಂದು ಶಕ್ತಿಯುತ ವೈಶಿಷ್ಟ್ಯವಾಗಿದ್ದು, ಇದು ನಿಮಗೆ ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ, ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಮತ್ತು ಟೈಪ್-ಸುರಕ್ಷಿತ ಕೋಡ್ ಬರೆಯಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ಟೈಪ್ ಚೆಕ್ಕಿಂಗ್ ಅನ್ನು ನಿರ್ವಹಿಸುವಾಗ ವಿವಿಧ ರೀತಿಯ ಟೈಪ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬಲ್ಲ ಟೈಪ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಇವುಗಳು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ. ಈ ಬ್ಲಾಗ್ ಪೋಸ್ಟ್ ಸುಧಾರಿತ ಬಳಕೆಯ ಮಾದರಿಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಎಲ್ಲಾ ಹಂತದ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅವರ ಭೌಗೋಳಿಕ ಸ್ಥಳ ಅಥವಾ ಹಿನ್ನೆಲೆಯನ್ನು ಲೆಕ್ಕಿಸದೆ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಒಳನೋಟಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು: ಒಂದು ಪುನರಾವಲೋಕನ

ಸುಧಾರಿತ ವಿಷಯಗಳಿಗೆ ಧುಮುಕುವ ಮೊದಲು, ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಪುನರಾವಲೋಕಿಸೋಣ. ಜೆನೆರಿಕ್ಸ್ ಒಂದೇ ಟೈಪ್‌ಗಿಂತ ಹೆಚ್ಚಾಗಿ ವಿವಿಧ ಟೈಪ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬಲ್ಲ ಕಾಂಪೊನೆಂಟ್‌ಗಳನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ನೀವು ಫಂಕ್ಷನ್ ಅಥವಾ ಕ್ಲಾಸ್ ಹೆಸರಿನ ನಂತರ ಆಂಗಲ್ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ (`<>`) ಜೆನೆರಿಕ್ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಘೋಷಿಸುತ್ತೀರಿ. ಈ ಪ್ಯಾರಾಮೀಟರ್ ಫಂಕ್ಷನ್ ಅಥವಾ ಕ್ಲಾಸ್ ಅನ್ನು ಬಳಸಿದಾಗ ನಂತರ ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗುವ ನಿಜವಾದ ಟೈಪ್‌ಗಾಗಿ ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ಉದಾಹರಣೆಗೆ, ಒಂದು ಸರಳ ಜೆನೆರಿಕ್ ಫಂಕ್ಷನ್ ಈ ರೀತಿ ಕಾಣಿಸಬಹುದು:

            function identity(arg: T): T {
  return arg;
}

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, T ಜೆನೆರಿಕ್ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್ ಆಗಿದೆ. identity ಫಂಕ್ಷನ್ T ಟೈಪಿನ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು T ಟೈಪಿನ ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ನಂತರ ನೀವು ಈ ಫಂಕ್ಷನ್ ಅನ್ನು ವಿವಿಧ ಟೈಪ್‌ಗಳೊಂದಿಗೆ ಕರೆಯಬಹುದು:

            
let stringResult: string = identity("hello");
let numberResult: number = identity(42);

            

              
                Copy
              
            
          

ಸುಧಾರಿತ ಜೆನೆರಿಕ್ಸ್: ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಮೀರಿ

ಈಗ, ಜೆನೆರಿಕ್ಸ್‌ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಹೆಚ್ಚು ಅತ್ಯಾಧುನಿಕ ವಿಧಾನಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ.

1. ಜೆನೆರಿಕ್ ಟೈಪ್ ಕನ್ಸ್ಟ್ರೈಂಟ್ಸ್

ಟೈಪ್ ಕನ್ಸ್ಟ್ರೈಂಟ್ಸ್ ಜೆನೆರಿಕ್ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ನೊಂದಿಗೆ ಬಳಸಬಹುದಾದ ಟೈಪ್‌ಗಳನ್ನು ನಿರ್ಬಂಧಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಜೆನೆರಿಕ್ ಟೈಪ್ ನಿರ್ದಿಷ್ಟ ಪ್ರಾಪರ್ಟಿಗಳು ಅಥವಾ ಮೆಥಡ್‌ಗಳನ್ನು ಹೊಂದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕಾದಾಗ ಇದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ನೀವು ಕನ್ಸ್ಟ್ರೈಂಟ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು extends ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸಬಹುದು.

ಒಂದು ಫಂಕ್ಷನ್ length ಪ್ರಾಪರ್ಟಿಯನ್ನು ಪ್ರವೇಶಿಸಬೇಕಾದ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸಿ:

            function loggingIdentity(arg: T): T {
  console.log(arg.length);
  return arg;
}

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, T ಅನ್ನು number ಟೈಪಿನ length ಪ್ರಾಪರ್ಟಿಯನ್ನು ಹೊಂದಿರುವ ಟೈಪ್‌ಗಳಿಗೆ ನಿರ್ಬಂಧಿಸಲಾಗಿದೆ. ಇದು ನಮಗೆ ಸುರಕ್ಷಿತವಾಗಿ arg.length ಅನ್ನು ಪ್ರವೇಶಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಈ ನಿರ್ಬಂಧವನ್ನು ಪೂರೈಸದ ಟೈಪ್ ಅನ್ನು ಪಾಸ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿದರೆ ಕಂಪೈಲ್-ಟೈಮ್ ದೋಷ ಉಂಟಾಗುತ್ತದೆ.

ಜಾಗತಿಕ ಅನ್ವಯ: ಇದು ಡೇಟಾ ಪ್ರೊಸೆಸಿಂಗ್ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ, ಉದಾಹರಣೆಗೆ ಅರೇಗಳು ಅಥವಾ ಸ್ಟ್ರಿಂಗ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ನೀವು ಆಗಾಗ್ಗೆ ಉದ್ದವನ್ನು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದಾಗ ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ. ನೀವು ಟೋಕಿಯೊ, ಲಂಡನ್, ಅಥವಾ ರಿಯೊ ಡಿ ಜನೈರೊದಲ್ಲಿರಲಿ, ಈ ಮಾದರಿಯು ಒಂದೇ ರೀತಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

2. ಇಂಟರ್‌ಫೇಸ್‌ಗಳೊಂದಿಗೆ ಜೆನೆರಿಕ್ ಬಳಕೆ

ಜೆನೆರಿಕ್ಸ್‌ಗಳು ಇಂಟರ್‌ಫೇಸ್‌ಗಳೊಂದಿಗೆ ಮನಬಂದಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ, ಇದು ನಿಮಗೆ ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಇಂಟರ್‌ಫೇಸ್ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಮಾಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

            interface GenericIdentityFn {
  (arg: T): T;
}

function identity(arg: T): T {
  return arg;
}

let myIdentity: GenericIdentityFn = identity;

            

              
                Copy
              
            
          

ಇಲ್ಲಿ, GenericIdentityFn ಎನ್ನುವುದು ಒಂದು ಇಂಟರ್‌ಫೇಸ್ ಆಗಿದ್ದು, ಅದು ಜೆನೆರಿಕ್ ಟೈಪ್ T ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಮತ್ತು ಅದೇ ಟೈಪ್ T ಅನ್ನು ಹಿಂದಿರುಗಿಸುವ ಫಂಕ್ಷನ್ ಅನ್ನು ವಿವರಿಸುತ್ತದೆ. ಇದು ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳುವಾಗ ವಿಭಿನ್ನ ಟೈಪ್ ಸಿಗ್ನೇಚರ್‌ಗಳೊಂದಿಗೆ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಜಾಗತಿಕ ದೃಷ್ಟಿಕೋನ: ಈ ಮಾದರಿಯು ವಿಭಿನ್ನ ರೀತಿಯ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗಾಗಿ ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಇಂಟರ್‌ಫೇಸ್‌ಗಳನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ವಿಭಿನ್ನ APIಗಳಲ್ಲಿ ಬಳಸಲಾಗುವ ಡೇಟಾ ವರ್ಗಾವಣೆ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗಾಗಿ (DTOs) ನೀವು ಜೆನೆರಿಕ್ ಇಂಟರ್‌ಫೇಸ್ ಅನ್ನು ರಚಿಸಬಹುದು, ಇದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಾದ್ಯಂತ ಅದನ್ನು ನಿಯೋಜಿಸಲಾದ ಪ್ರದೇಶವನ್ನು ಲೆಕ್ಕಿಸದೆ ಸ್ಥಿರವಾದ ಡೇಟಾ ರಚನೆಗಳನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

3. ಜೆನೆರಿಕ್ ಕ್ಲಾಸ್‌ಗಳು

ಕ್ಲಾಸ್‌ಗಳು ಸಹ ಜೆನೆರಿಕ್ ಆಗಿರಬಹುದು:

            
class GenericNumber {
  zeroValue: T;
  add: (x: T, y: T) => T;
}

let myGenericNumber = new GenericNumber();
myGenericNumber.zeroValue = 0;
myGenericNumber.add = function(x, y) { return x + y; };

            

              
                Copy
              
            
          

ಈ GenericNumber ಕ್ಲಾಸ್ T ಟೈಪಿನ ಮೌಲ್ಯವನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳಬಹುದು ಮತ್ತು T ಟೈಪಿನ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವ add ಮೆಥಡ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು. ನೀವು ಬಯಸಿದ ಟೈಪ್‌ನೊಂದಿಗೆ ಕ್ಲಾಸ್ ಅನ್ನು ಇನ್‌ಸ್ಟಾಂಷಿಯೇಟ್ ಮಾಡುತ್ತೀರಿ. ಇದು ಸ್ಟಾಕ್‌ಗಳು ಅಥವಾ ಕ್ಯೂಗಳಂತಹ ಡೇಟಾ ರಚನೆಗಳನ್ನು ರಚಿಸಲು ಬಹಳ ಸಹಾಯಕವಾಗಬಹುದು.

ಜಾಗತಿಕ ಅನ್ವಯ: ವಿವಿಧ ಕರೆನ್ಸಿಗಳನ್ನು (ಉದಾ. USD, EUR, JPY) ಸಂಗ್ರಹಿಸಿ ಪ್ರೊಸೆಸ್ ಮಾಡಬೇಕಾದ ಹಣಕಾಸು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ನೀವು CurrencyAmount ಕ್ಲಾಸ್ ಅನ್ನು ರಚಿಸಲು ಜೆನೆರಿಕ್ ಕ್ಲಾಸ್ ಅನ್ನು ಬಳಸಬಹುದು, ಇಲ್ಲಿ T ಕರೆನ್ಸಿ ಟೈಪ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಇದು ವಿವಿಧ ಕರೆನ್ಸಿ ಮೊತ್ತಗಳ ಟೈಪ್-ಸುರಕ್ಷಿತ ಲೆಕ್ಕಾಚಾರಗಳು ಮತ್ತು ಸಂಗ್ರಹಣೆಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

4. ಬಹು ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು

ಜೆನೆರಿಕ್ಸ್‌ಗಳು ಬಹು ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು:

            
function swap(a: T, b: U): [U, T] {
  return [b, a];
}

let result = swap("hello", 42);
// result[0] is number, result[1] is string

            

              
                Copy
              
            
          

swap ಫಂಕ್ಷನ್ ಎರಡು ವಿಭಿನ್ನ ಟೈಪ್‌ಗಳ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಟೈಪ್‌ಗಳನ್ನು ಅದಲುಬದಲು ಮಾಡಿದ ಟಪಲ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

ಜಾಗತಿಕ ಪ್ರಸ್ತುತತೆ: ಅಂತರರಾಷ್ಟ್ರೀಯ ವ್ಯಾಪಾರ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ, ನೀವು ವಿಭಿನ್ನ ಟೈಪ್‌ಗಳ ಎರಡು ಸಂಬಂಧಿತ ಡೇಟಾ ತುಣುಕುಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಮತ್ತು ಅವುಗಳ ಟಪಲ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುವ ಫಂಕ್ಷನ್ ಅನ್ನು ಹೊಂದಿರಬಹುದು, ಉದಾಹರಣೆಗೆ ಗ್ರಾಹಕರ ID (ಸ್ಟ್ರಿಂಗ್) ಮತ್ತು ಆರ್ಡರ್ ಮೌಲ್ಯ (ಸಂಖ್ಯೆ). ಈ ಮಾದರಿಯು ಯಾವುದೇ ನಿರ್ದಿಷ್ಟ ದೇಶಕ್ಕೆ ಆದ್ಯತೆ ನೀಡುವುದಿಲ್ಲ ಮತ್ತು ಜಾಗತಿಕ ಅಗತ್ಯಗಳಿಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ.

5. ಜೆನೆರಿಕ್ ಕನ್ಸ್ಟ್ರೈಂಟ್ಸ್‌ನಲ್ಲಿ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಬಳಕೆ

ನೀವು ಕನ್ಸ್ಟ್ರೈಂಟ್ ಒಳಗೆ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಬಳಸಬಹುದು.

            
function getProperty(obj: T, key: K) {
  return obj[key];
}

let obj = { a: 1, b: 2, c: 3 };

let value = getProperty(obj, "a"); // value is number

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, K extends keyof T ಎಂದರೆ K ಕೇವಲ T ಟೈಪಿನ ಕೀ ಆಗಿರಬಹುದು. ಇದು ಆಬ್ಜೆಕ್ಟ್ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಡೈನಾಮಿಕ್ ಆಗಿ ಪ್ರವೇಶಿಸುವಾಗ ಬಲವಾದ ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಜಾಗತಿಕ ಅನ್ವಯಿಸುವಿಕೆ: ಕಾನ್ಫಿಗರೇಶನ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಅಥವಾ ಡೇಟಾ ರಚನೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ, ಅಲ್ಲಿ ಪ್ರಾಪರ್ಟಿ ಪ್ರವೇಶವನ್ನು ಅಭಿವೃದ್ಧಿಯ ಸಮಯದಲ್ಲಿ ಮೌಲ್ಯೀಕರಿಸಬೇಕಾಗುತ್ತದೆ. ಈ ತಂತ್ರವನ್ನು ಯಾವುದೇ ದೇಶದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಅನ್ವಯಿಸಬಹುದು.

6. ಜೆನೆರಿಕ್ ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಹಲವಾರು ಅಂತರ್ನಿರ್ಮಿತ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಅವು ಸಾಮಾನ್ಯ ಟೈಪ್ ರೂಪಾಂತರಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಜೆನೆರಿಕ್ಸ್‌ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತವೆ. ಇವುಗಳಲ್ಲಿ ಕೆಲವು:

• Partial: T ಯ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಐಚ್ಛಿಕವಾಗಿಸುತ್ತದೆ.
• Required: T ಯ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಕಡ್ಡಾಯವಾಗಿಸುತ್ತದೆ.
• Readonly: T ಯ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ರೀಡ್-ಓನ್ಲಿ ಮಾಡುತ್ತದೆ.
• Pick: T ಯಿಂದ ಪ್ರಾಪರ್ಟಿಗಳ ಗುಂಪನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ.
• Omit: T ಯಿಂದ ಪ್ರಾಪರ್ಟಿಗಳ ಗುಂಪನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ.

ಉದಾಹರಣೆಗೆ:

            
interface User {
  id: number;
  name: string;
  email: string;
}

// Partial - all properties optional
let optionalUser: Partial = {};

// Pick - only id and name properties
let userSummary: Pick = { id: 1, name: 'John' };

            

              
                Copy
              
            
          

ಜಾಗತಿಕ ಬಳಕೆಯ ಪ್ರಕರಣ: API ವಿನಂತಿ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆ ಮಾದರಿಗಳನ್ನು ರಚಿಸುವಾಗ ಈ ಯುಟಿಲಿಟಿಗಳು ಅಮೂಲ್ಯವಾಗಿವೆ. ಉದಾಹರಣೆಗೆ, ಜಾಗತಿಕ ಇ-ಕಾಮರ್ಸ್ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ, Partial ಅನ್ನು ಅಪ್‌ಡೇಟ್ ವಿನಂತಿಯನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಬಳಸಬಹುದು (ಅಲ್ಲಿ ಕೆಲವು ಉತ್ಪನ್ನ ವಿವರಗಳನ್ನು ಮಾತ್ರ ಕಳುಹಿಸಲಾಗುತ್ತದೆ), ಆದರೆ Readonly ಫ್ರಂಟ್-ಎಂಡ್‌ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾದ ಉತ್ಪನ್ನವನ್ನು ಪ್ರತಿನಿಧಿಸಬಹುದು.

7. ಜೆನೆರಿಕ್ಸ್‌ಗಳೊಂದಿಗೆ ಟೈಪ್ ಇನ್ಫರೆನ್ಸ್

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಆಗಾಗ್ಗೆ ನೀವು ಜೆನೆರಿಕ್ ಫಂಕ್ಷನ್ ಅಥವಾ ಕ್ಲಾಸ್‌ಗೆ ಪಾಸ್ ಮಾಡುವ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಊಹಿಸಬಹುದು. ಇದು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸ್ವಚ್ಛವಾಗಿ ಮತ್ತು ಓದಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ.

            
function createPair(a: T, b: T): [T, T] {
  return [a, b];
}

let pair = createPair("hello", "world"); // TypeScript infers T as string

            

              
                Copy
              
            
          

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ T ಯು string ಎಂದು ಊಹಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಎರಡೂ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು ಸ್ಟ್ರಿಂಗ್‌ಗಳಾಗಿವೆ.

ಜಾಗತಿಕ ಪ್ರಭಾವ: ಟೈಪ್ ಇನ್ಫರೆನ್ಸ್ ಸ್ಪಷ್ಟವಾದ ಟೈಪ್ ವಿವರಣೆಗಳ ಅಗತ್ಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ, ಇದು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಸಂಕ್ಷಿಪ್ತ ಮತ್ತು ಓದಬಲ್ಲದಾಗಿಸುತ್ತದೆ. ಇದು ವಿವಿಧ ಅಭಿವೃದ್ಧಿ ತಂಡಗಳಾದ್ಯಂತ ಸಹಯೋಗವನ್ನು ಸುಧಾರಿಸುತ್ತದೆ, ಅಲ್ಲಿ ವಿವಿಧ ಹಂತದ ಅನುಭವಗಳು ಇರಬಹುದು.

8. ಜೆನೆರಿಕ್ಸ್‌ಗಳೊಂದಿಗೆ ಕಂಡಿಷನಲ್ ಟೈಪ್ಸ್

ಕಂಡಿಷನಲ್ ಟೈಪ್ಸ್, ಜೆನೆರಿಕ್ಸ್‌ಗಳ ಸಂಯೋಜನೆಯಲ್ಲಿ, ಇತರ ಟೈಪ್‌ಗಳ ಮೌಲ್ಯಗಳನ್ನು ಅವಲಂಬಿಸಿರುವ ಟೈಪ್‌ಗಳನ್ನು ರಚಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ.

            
type Check = T extends string ? string : number;

let result1: Check = "hello"; // string
let result2: Check = 42; // number

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, Check, T ಯು string ಅನ್ನು ವಿಸ್ತರಿಸಿದರೆ string ಎಂದು ಮೌಲ್ಯಮಾಪನಗೊಳ್ಳುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ ಅದು number ಎಂದು ಮೌಲ್ಯಮಾಪನಗೊಳ್ಳುತ್ತದೆ.

ಜಾಗತಿಕ ಸಂದರ್ಭ: ನಿರ್ದಿಷ್ಟ ಪರಿಸ್ಥಿತಿಗಳ ಆಧಾರದ ಮೇಲೆ ಟೈಪ್‌ಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ರೂಪಿಸಲು ಕಂಡಿಷನಲ್ ಟೈಪ್ಸ್ ಅತ್ಯಂತ ಉಪಯುಕ್ತವಾಗಿವೆ. ಪ್ರದೇಶದ ಆಧಾರದ ಮೇಲೆ ಡೇಟಾವನ್ನು ಪ್ರೊಸೆಸ್ ಮಾಡುವ ವ್ಯವಸ್ಥೆಯನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ನಂತರ ಕಂಡಿಷನಲ್ ಟೈಪ್‌ಗಳನ್ನು ಪ್ರದೇಶ-ನಿರ್ದಿಷ್ಟ ಡೇಟಾ ಸ್ವರೂಪಗಳು ಅಥವಾ ಡೇಟಾ ಟೈಪ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ಡೇಟಾವನ್ನು ರೂಪಾಂತರಿಸಲು ಬಳಸಬಹುದು. ಜಾಗತಿಕ ಡೇಟಾ ಆಡಳಿತದ ಅವಶ್ಯಕತೆಗಳನ್ನು ಹೊಂದಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಇದು ನಿರ್ಣಾಯಕವಾಗಿದೆ.

9. ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ಸ್‌ಗಳೊಂದಿಗೆ ಜೆನೆರಿಕ್ಸ್‌ಗಳ ಬಳಕೆ

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ಸ್ ಮತ್ತೊಂದು ಟೈಪ್‌ನ ಆಧಾರದ ಮೇಲೆ ಒಂದು ಟೈಪ್‌ನ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ರೂಪಾಂತರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ನಮ್ಯತೆಗಾಗಿ ಅವುಗಳನ್ನು ಜೆನೆರಿಕ್ಸ್‌ಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ:

            
type OptionsFlags = {
  [K in keyof T]: boolean;
};

interface FeatureFlags {
  darkMode: boolean;
  notifications: boolean;
}

// Create a type where each feature flag is enabled (true) or disabled (false)
let featureFlags: OptionsFlags = {
  darkMode: true,
  notifications: false,
};

            

              
                Copy
              
            
          

OptionsFlags ಟೈಪ್ ಜೆನೆರಿಕ್ ಟೈಪ್ T ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಹೊಸ ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಅಲ್ಲಿ T ಯ ಪ್ರಾಪರ್ಟಿಗಳು ಈಗ ಬೂಲಿಯನ್ ಮೌಲ್ಯಗಳಿಗೆ ಮ್ಯಾಪ್ ಆಗಿವೆ. ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳು ಅಥವಾ ಫೀಚರ್ ಫ್ಲ್ಯಾಗ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಇದು ತುಂಬಾ ಶಕ್ತಿಯುತವಾಗಿದೆ.

ಜಾಗತಿಕ ಅನ್ವಯ: ಈ ಮಾದರಿಯು ಪ್ರದೇಶ-ನಿರ್ದಿಷ್ಟ ಸೆಟ್ಟಿಂಗ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ಕಾನ್ಫಿಗರೇಶನ್ ಸ್ಕೀಮಾಗಳನ್ನು ರಚಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ಈ ವಿಧಾನವು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಪ್ರದೇಶ-ನಿರ್ದಿಷ್ಟ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅನುಮತಿಸುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, ಒಂದು ಪ್ರದೇಶದಲ್ಲಿ ಬೆಂಬಲಿತ ಭಾಷೆಗಳು). ಇದು ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್ ಕಾನ್ಫಿಗರೇಶನ್ ಸ್ಕೀಮಾಗಳನ್ನು ಸುಲಭವಾಗಿ ರಚಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

10. `infer` ಕೀವರ್ಡ್‌ನೊಂದಿಗೆ ಸುಧಾರಿತ ಇನ್ಫರೆನ್ಸ್

infer ಕೀವರ್ಡ್ ಕಂಡಿಷನಲ್ ಟೈಪ್ಸ್‌ಗಳ ಒಳಗೆ ಇತರ ಟೈಪ್ಸ್‌ಗಳಿಂದ ಟೈಪ್ಸ್‌ಗಳನ್ನು ಹೊರತೆಗೆಯಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

            
type ReturnType any> = T extends (...args: any) => infer R ? R : any;

function myFunction(): string {
  return "hello";
}

let result: ReturnType = "hello"; // result is string

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯು infer ಕೀವರ್ಡ್ ಬಳಸಿ ಫಂಕ್ಷನ್‌ನ ರಿಟರ್ನ್ ಟೈಪ್ ಅನ್ನು ಊಹಿಸುತ್ತದೆ. ಇದು ಹೆಚ್ಚು ಸುಧಾರಿತ ಟೈಪ್ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್‌ಗಾಗಿ ಒಂದು ಅತ್ಯಾಧುನಿಕ ತಂತ್ರವಾಗಿದೆ.

ಜಾಗತಿಕ ಮಹತ್ವ: ಈ ತಂತ್ರವು ದೊಡ್ಡ, ವಿತರಿಸಿದ ಜಾಗತಿಕ ಸಾಫ್ಟ್‌ವೇರ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ ಸಂಕೀರ್ಣ ಫಂಕ್ಷನ್ ಸಿಗ್ನೇಚರ್‌ಗಳು ಮತ್ತು ಸಂಕೀರ್ಣ ಡೇಟಾ ರಚನೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಒದಗಿಸಲು ಅತ್ಯಗತ್ಯವಾಗಿರುತ್ತದೆ. ಇದು ಇತರ ಟೈಪ್ಸ್‌ಗಳಿಂದ ಡೈನಾಮಿಕ್ ಆಗಿ ಟೈಪ್ಸ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಕೋಡ್ ನಿರ್ವಹಣೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ.

ಅತ್ಯುತ್ತಮ ಅಭ್ಯಾಸಗಳು ಮತ್ತು ಸಲಹೆಗಳು

• ಅರ್ಥಪೂರ್ಣ ಹೆಸರುಗಳನ್ನು ಬಳಸಿ: ನಿಮ್ಮ ಜೆನೆರಿಕ್ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳಿಗೆ ವಿವರಣಾತ್ಮಕ ಹೆಸರುಗಳನ್ನು (ಉದಾ., TValue, TKey) ಆರಿಸಿ, ಓದುವಿಕೆಯನ್ನು ಸುಧಾರಿಸಲು.
• ನಿಮ್ಮ ಜೆನೆರಿಕ್ಸ್‌ಗಳನ್ನು ದಾಖಲಿಸಿ: ನಿಮ್ಮ ಜೆನೆರಿಕ್ ಟೈಪ್ಸ್ ಮತ್ತು ಕನ್ಸ್ಟ್ರೈಂಟ್ಸ್‌ನ ಉದ್ದೇಶವನ್ನು ವಿವರಿಸಲು JSDoc ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಬಳಸಿ. ಇದು ತಂಡದ ಸಹಯೋಗಕ್ಕೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ಜಗತ್ತಿನಾದ್ಯಂತ ವಿತರಿಸಲಾದ ತಂಡಗಳೊಂದಿಗೆ.
• ಸರಳವಾಗಿಡಿ: ನಿಮ್ಮ ಜೆನೆರಿಕ್ಸ್‌ಗಳನ್ನು ಅತಿಯಾಗಿ ಇಂಜಿನಿಯರಿಂಗ್ ಮಾಡುವುದನ್ನು ತಪ್ಪಿಸಿ. ಸರಳ ಪರಿಹಾರಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ನಿಮ್ಮ ಅಗತ್ಯಗಳು ವಿಕಸನಗೊಂಡಂತೆ ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡಿ. ಅತಿಯಾದ ಸಂಕೀರ್ಣತೆಯು ಕೆಲವು ತಂಡದ ಸದಸ್ಯರಿಗೆ ತಿಳುವಳಿಕೆಯನ್ನು ಅಡ್ಡಿಪಡಿಸಬಹುದು.
• ವ್ಯಾಪ್ತಿಯನ್ನು ಪರಿಗಣಿಸಿ: ನಿಮ್ಮ ಜೆನೆರಿಕ್ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ವ್ಯಾಪ್ತಿಯನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಪರಿಗಣಿಸಿ. ಉದ್ದೇಶಪೂರ್ವಕವಲ್ಲದ ಟೈಪ್ ಅಸಾಮರಸ್ಯಗಳನ್ನು ತಪ್ಪಿಸಲು ಅವು ಸಾಧ್ಯವಾದಷ್ಟು ಕಿರಿದಾಗಿರಬೇಕು.
• ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್‌ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಿ: ಸಾಧ್ಯವಾದಾಗಲೆಲ್ಲಾ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಅಂತರ್ನಿರ್ಮಿತ ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್‌ಗಳನ್ನು ಬಳಸಿ. ಅವು ನಿಮ್ಮ ಸಮಯ ಮತ್ತು ಶ್ರಮವನ್ನು ಉಳಿಸಬಹುದು.
• ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಿ: ನಿಮ್ಮ ಜೆನೆರಿಕ್ ಕೋಡ್ ವಿವಿಧ ಟೈಪ್ಸ್‌ಗಳೊಂದಿಗೆ ನಿರೀಕ್ಷೆಯಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸಮಗ್ರ ಯುನಿಟ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಿರಿ.

ತೀರ್ಮಾನ: ಜೆನೆರಿಕ್ಸ್‌ಗಳ ಶಕ್ತಿಯನ್ನು ಜಾಗತಿಕವಾಗಿ ಅಳವಡಿಸಿಕೊಳ್ಳುವುದು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಜೆನೆರಿಕ್ಸ್ ದೃಢವಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಲ್ಲ ಕೋಡ್ ಬರೆಯುವಲ್ಲಿ ಒಂದು ಮೂಲಾಧಾರವಾಗಿದೆ. ಈ ಸುಧಾರಿತ ಮಾದರಿಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನಿಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಟೈಪ್ ಸುರಕ್ಷತೆ, ಮರುಬಳಕೆ ಮತ್ತು ಒಟ್ಟಾರೆ ಗುಣಮಟ್ಟವನ್ನು ನೀವು ಗಣನೀಯವಾಗಿ ಹೆಚ್ಚಿಸಬಹುದು. ಸರಳ ಟೈಪ್ ಕನ್ಸ್ಟ್ರೈಂಟ್ಸ್‌ನಿಂದ ಸಂಕೀರ್ಣ ಕಂಡಿಷನಲ್ ಟೈಪ್ಸ್‌ಗಳವರೆಗೆ, ಜೆನೆರಿಕ್ಸ್ ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ಸ್ಕೇಲೆಬಲ್ ಮತ್ತು ನಿರ್ವಹಿಸಬಲ್ಲ ಸಾಫ್ಟ್‌ವೇರ್ ನಿರ್ಮಿಸಲು ಬೇಕಾದ ಸಾಧನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ನಿಮ್ಮ ಭೌಗೋಳಿಕ ಸ್ಥಳವನ್ನು ಲೆಕ್ಕಿಸದೆ ಜೆನೆರಿಕ್ಸ್ ಬಳಸುವ ತತ್ವಗಳು ಸ್ಥಿರವಾಗಿರುತ್ತವೆ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ.

ಈ ಲೇಖನದಲ್ಲಿ ಚರ್ಚಿಸಲಾದ ತಂತ್ರಗಳನ್ನು ಅನ್ವಯಿಸುವ ಮೂಲಕ, ನೀವು ಉತ್ತಮ-ರಚನಾತ್ಮಕ, ಹೆಚ್ಚು ವಿಶ್ವಾಸಾರ್ಹ ಮತ್ತು ಸುಲಭವಾಗಿ ವಿಸ್ತರಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ರಚಿಸಬಹುದು, ಇದು ಅಂತಿಮವಾಗಿ ನೀವು ತೊಡಗಿಸಿಕೊಂಡಿರುವ ದೇಶ, ಖಂಡ, ಅಥವಾ ವ್ಯವಹಾರವನ್ನು ಲೆಕ್ಕಿಸದೆ ಹೆಚ್ಚು ಯಶಸ್ವಿ ಸಾಫ್ಟ್‌ವೇರ್ ಯೋಜನೆಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಜೆನೆರಿಕ್ಸ್‌ಗಳನ್ನು ಅಪ್ಪಿಕೊಳ್ಳಿ, ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್ ನಿಮಗೆ ಧನ್ಯವಾದ ಹೇಳುತ್ತದೆ!